package com.fh.shop.api.cart.biz;

import com.alibaba.fastjson.JSON;
import com.fh.shop.api.cart.vo.CartItemVo;
import com.fh.shop.api.cart.vo.CartVo;
import com.fh.shop.api.common.Constant;
import com.fh.shop.api.common.ResponseEnum;
import com.fh.shop.api.common.ServerResponse;
import com.fh.shop.api.product.mapper.IProductMapper;
import com.fh.shop.api.product.po.Product;
import com.fh.shop.api.util.BigDecimalUtil;
import com.fh.shop.api.util.KeyUtil;
import com.fh.shop.api.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

@Service("cartService")
public class ICartServiceImpl implements ICartService {
    @Resource
    private IProductMapper productMapper;

    //加入购物车
    @Override
    public ServerResponse addCart(Long productId, Long count, Long memberId) {
        //判断商品的数量是否正常
        if (count.longValue() == 0){
            return ServerResponse.error(ResponseEnum.CART_PRODUCT_COUNT_ERROR);
        }

        Product product = productMapper.selectById(productId);
        //判断是否有这个商品
        if (product == null){
            return ServerResponse.error(ResponseEnum.CART_PRODUCT_IS_NULL);
        }

        //判断是否是上架的商品
        Integer status = product.getStatus();
        if (status.intValue() == 0){
            return ServerResponse.error(ResponseEnum.CART_PRODUCT_IS_DOWN);
        }

        //判断商品库存
        Long stock = product.getStock();
        if (stock < count){
            return ServerResponse.error(ResponseEnum.CART_PRODUCT_IS_NOT);
        }

        //判断是否有购物车
        String key = KeyUtil.CartKey(memberId);
//        String cartValue = RedisUtil.get(key);
        String cartValue = RedisUtil.hget(key, Constant.MEMBER_CART);
        if (cartValue == null){
            //先判断商品的数量是否正常
            if (count < 0 ){
                return ServerResponse.error(ResponseEnum.CART_PRODUCT_COUNT_ERROR);
            }

            //没有购物车，创建购物车
            CartVo cartVo = new CartVo();
            CartItemVo cartItemVo = buildCartItemVo(productId, count, product);

            //放入购物车
            cartVo.getCartItemVoList().add(cartItemVo);
            cartVo.setTotalCount(count);
            cartVo.setTotalSumPrice(cartItemVo.getTotalPrice());

            //将购物车存到缓存中
            String cartVoJson = JSON.toJSONString(cartVo);
//            RedisUtil.set(key,cartVoJson);
//            RedisUtil.hset(key,Constant.MEMBER_CART,cartVoJson);
//            RedisUtil.hset(key,Constant.MEMBER_CART_COUNT,cartVo.getTotalSumPrice());
            Map<String ,String> map = new HashMap<>();
            map.put(Constant.MEMBER_CART,cartVoJson);
            map.put(Constant.MEMBER_CART_COUNT,cartVo.getTotalCount() + "");
            RedisUtil.hmset(key,map);

        }else {
            //有购物车，获取购物车
            CartVo cartVo = JSON.parseObject(cartValue, CartVo.class);
            //判断购物车中有没有这个商品
            Optional<CartItemVo> optionalCartItemVo = cartVo.getCartItemVoList()
                                    .stream()
                                    .filter(x -> x.getId().longValue() == productId.longValue())
                                    .findFirst();
            if (optionalCartItemVo.isPresent()){
                //有这个商品就更新信息
                CartItemVo cartItemVo = optionalCartItemVo.get();
                //更新商品数量
                long newCount = cartItemVo.getCount() + count;
                cartItemVo.setCount(newCount);

                //如果商品的数量小于0,就删除这个商品
                if(newCount <= 0){
                    cartVo.getCartItemVoList().removeIf(x -> x.getId().longValue() == cartItemVo.getId().longValue());
                    //判断商品是否为空
                    if (cartVo.getCartItemVoList().size() == 0){
                        RedisUtil.del(key);
                        return ServerResponse.success();
                    }
                    updateCart(memberId, cartVo);
                    return ServerResponse.success();
                }

                //更新商品合计金额
                String price = product.getPrice().toString();
                String totalPrice = BigDecimalUtil.mul(price, newCount + "").toString();
                cartItemVo.setTotalPrice(totalPrice);
                //更新数据
                updateCart(memberId, cartVo);


            }else {
                //先判断商品的数量是否正常
                if (count < 0 ){
                    return ServerResponse.error(ResponseEnum.CART_PRODUCT_COUNT_ERROR);
                }

                //没有这个商品创建商品
                CartItemVo cartItemVo = buildCartItemVo(productId, count, product);

                //更新商品
                cartVo.getCartItemVoList().add(cartItemVo);

                //循环遍历每一项更新数据
                updateCart(memberId, cartVo);
            }
        }

        return ServerResponse.success();
    }

    //删除单个购物车商品
    @Override
    public ServerResponse deleteCart(Long id, Long memberId) {
        //验证有没有购物车
        String key = KeyUtil.CartKey(memberId);
        String cartVoJson = RedisUtil.hget(key,Constant.MEMBER_CART);
        if (cartVoJson != null){
            //有购物车,获取购物车
            CartVo cartVo = JSON.parseObject(cartVoJson, CartVo.class);
            //删除商品
            List<CartItemVo> cartItemVoList = cartVo.getCartItemVoList();
            //有商品判断商品id是否符合要求
            long count = cartItemVoList.stream().filter(x -> x.getId().longValue() == id.longValue()).count();
            if (count == 0){
                return ServerResponse.error(ResponseEnum.CART_PRODUCT_ID_ERROR);
            }
            cartItemVoList.removeIf(x -> x.getId().longValue() == id.longValue());
            //更新购物车
            updateCart(memberId,cartVo);

            if (cartItemVoList.size() == 0){
                //没有商品则删除购物车
                RedisUtil.del(key);
            }
        }else {
            return ServerResponse.error(ResponseEnum.CART_IS_NULL);
        }
        return ServerResponse.success();
    }

    //批量删除购物车的商品
    @Override
    public ServerResponse deleteBatch(String ids, Long memberId) {
        //验证ids
        if (StringUtils.isNotEmpty(ids)){
            //验证购物车
            String key = KeyUtil.CartKey(memberId);
            String cartVoJson = RedisUtil.hget(key,Constant.MEMBER_CART);
            if (cartVoJson != null){
                String[] idArr = ids.split(",");
                //有购物车,获取购物车
                CartVo cartVo = JSON.parseObject(cartVoJson, CartVo.class);
                List<CartItemVo> cartItemVoList = cartVo.getCartItemVoList();
                //删除商品
                Arrays.stream(idArr).forEach(x -> {
                    //循环遍历ids删除
                    cartItemVoList.removeIf(y -> y.getId().longValue() == Long.parseLong(x));
                });
                //查看购物车是否需要更新
                if (cartItemVoList.size() == 0){
                    //没有商品则删除购物车
                    RedisUtil.del(key);
                }else {
                    //还有商品就更新购物车
                    updateCart(memberId,cartVo);
                }
            }else {
                return ServerResponse.error(ResponseEnum.CART_IS_NULL);
            }
        }
        return ServerResponse.success();
    }

    //查询购物车条数
    @Override
    public ServerResponse queryCartCount(Long memberId) {
        //获取购物车的数量
        String key = KeyUtil.CartKey(memberId);
        String cartCount = RedisUtil.hget(key, Constant.MEMBER_CART_COUNT);
        if (!RedisUtil.exists(key)){
            return ServerResponse.error(ResponseEnum.CART_IS_NULL);
        }
        return ServerResponse.success(cartCount);
    }

    private CartItemVo buildCartItemVo(Long productId, Long count, Product product) {
        //创建商品
        CartItemVo cartItemVo = new CartItemVo();
        cartItemVo.setId(productId);
        cartItemVo.setCount(count);
        String price = product.getPrice().toString();
        cartItemVo.setPrice(price);
        cartItemVo.setProductName(product.getProductName());
        cartItemVo.setImage(product.getMainImage());
        String totalPrice = BigDecimalUtil.mul(price, count + "").toString();
        cartItemVo.setTotalPrice(totalPrice);
        return cartItemVo;
    }

    private void updateCart(Long memberId, CartVo cartVo) {
        //循环遍历每一项更新数据
        long newTotalCount = 0;
        BigDecimal newTotalSumPrice = new BigDecimal(0);
        for (CartItemVo itemVo : cartVo.getCartItemVoList()) {
            //更新条数
            newTotalCount += itemVo.getCount();
            //更新金额
            newTotalSumPrice = newTotalSumPrice.add(new BigDecimal(itemVo.getTotalPrice()));
        }

        //放入购物车
        cartVo.setTotalCount(newTotalCount);
        cartVo.setTotalSumPrice(newTotalSumPrice.toString());

        //将购物车存到缓存中
        String cartVoJson = JSON.toJSONString(cartVo);
        String key = KeyUtil.CartKey(memberId);
//        RedisUtil.hset(key,Constant.MEMBER_CART, cartVoJson);
//        RedisUtil.hset(key,Constant.MEMBER_CART_COUNT, cartVo.getTotalSumPrice());
        Map<String ,String> map = new HashMap<>();
        map.put(Constant.MEMBER_CART,cartVoJson);
        map.put(Constant.MEMBER_CART_COUNT,cartVo.getTotalCount() + "");
        RedisUtil.hmset(key,map);
    }
}
